home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume3 / head < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  14.7 KB
  1. From: bene!luke!itkin
  2. Subject: head(1), and ctags(1) for AT&T type systems
  3. Reply-To: itkin@luke.UUCP (Steven List)
  4. Newsgroups: mod.sources
  5. Approved: jpn@panda.UUCP
  6.  
  7. Mod.sources:  Volume 3, Issue 87
  8. Submitted by: Steven List <bene!luke!itkin>
  9.  
  10.  
  11. # I've recently had the  pleasure  (?)  of  working  with  an  AT&T
  12. # 3B2/300.   Among  the  many  differences  I  encountered  are the
  13. # absences of the Berkeley  commands  head(1)  and  ctags(1).   I'd
  14. # gotten  used  to those command due to the generosity of Plexus in
  15. # providing them on their System III and V  systems.   Needless  to
  16. # say I immediately sat down and wrote them.
  17. # 
  18. # My version of head(1) adds a command line option to the standard:
  19. # +n.   In  this  case,  +n means "skip n lines before displaying".
  20. # Yes, I'm aware that I could use  sed(1)  for  this.   But  sed(1)
  21. # doesn't stop when it has done what you asked.  It still processes
  22. # to the end of file.  So, I figured that I'd  just  add  this  one
  23. # little feature.
  24. # 
  25. # My version of ctags(1) is pretty much the same  as  the  Berkeley
  26. # one,  as  far  as  I  can  tell.   It uses some code to recognize
  27. # function declarations that I borrowed from `cpr'  (I  don't  have
  28. # the  original author's name).  It is simple, straightforward, and
  29. # readily modified.
  30. # 
  31. # As always, comments, changes, and corrections are welcome.
  32. # 
  33. # Steven
  34. # 
  35. ###
  36. #  Steven List @ Benetics Corporation, Mt. View, CA
  37. #  Just part of the stock at "Uncle Bene's Farm"
  38. #  {cdp,engfocus,greipa,idi,oliveb,plx,sun,tolerant}!bene!luke!itkin
  39. ###
  40. #! /bin/sh
  41. # This is a shell archive, meaning:
  42. # 1. Remove everything above the #! /bin/sh line.
  43. # 2. Save the resulting text in a file.
  44. # 3. Execute the file with /bin/sh (not csh) to create the files:
  45. #    head.c
  46. #    ctags.c
  47. # This archive created: Sat Dec 14 17:38:46 1985
  48. export PATH; PATH=/bin:$PATH
  49. echo shar: extracting "'head.c'" '(4938 characters)'
  50. if test -f 'head.c'
  51. then
  52.     echo shar: will not over-write existing file "'head.c'"
  53. else
  54. sed 's/^ZZ//' << \SHAR_EOF > 'head.c'
  55. ZZ/* head - replace head command */
  56. ZZ/*
  57. ZZ * call: head [ +n ] [ -n ] [ file ... ]
  58. ZZ *
  59. ZZ *       +n = number of lines to skip before starting display
  60. ZZ *            default = 0
  61. ZZ *       -n = number of lines to display, starting with top of file
  62. ZZ *            default = 10
  63. ZZ *       file = any number of files may be present
  64. ZZ *                if name is `-', read from standard input
  65. ZZ */
  66. ZZ#include    <stdio.h>
  67. ZZ
  68. ZZ#define FALSE 0
  69. ZZ#define TRUE 1
  70. ZZ
  71. ZZvoid dofile ();
  72. ZZ
  73. ZZmain (ac, av)
  74. ZZint     ac;
  75. ZZchar    **av;
  76. ZZ{
  77. ZZ    register FILE *in = stdin;          /* default is standard input    */
  78. ZZ
  79. ZZ    register int header = FALSE;        /* TRUE if multiple files       */
  80. ZZ
  81. ZZ    register char *cp;                  /* general purpose pointer      */
  82. ZZ
  83. ZZ    register long nlines = 10;          /* number of lines to display   */
  84. ZZ    register long skip = 0;             /* number of lines to skip      */
  85. ZZ
  86. ZZ    register char *pgm;                 /* program name                 */
  87. ZZ
  88. ZZ    if (pgm = strrchr (av[0], '/')) pgm++;
  89. ZZ    else                            pgm = av[0];
  90. ZZ
  91. ZZ    /* ------------------------------------------------------------ */
  92. ZZ    /* Adjust args to skip program name                             */
  93. ZZ    /* ------------------------------------------------------------ */
  94. ZZ
  95. ZZ    av++; ac--;
  96. ZZ
  97. ZZ    /* ------------------------------------------------------------ */
  98. ZZ    /* process arguments/options                                    */
  99. ZZ    /*   it is assumed that the options will precede all file names */
  100. ZZ    /*   on the command line                                        */
  101. ZZ    /* ------------------------------------------------------------ */
  102. ZZ
  103. ZZ    while (ac)
  104. ZZ    {
  105. ZZ        if (*av[0] == '+')              /* lines to skip            */
  106. ZZ        {
  107. ZZ            skip = atoi (&av[0][1]);
  108. ZZ            ac--; av++;
  109. ZZ        }
  110. ZZ        else if (*av[0] == '-')         /* lines to display         */
  111. ZZ        {
  112. ZZ            nlines = atoi (&av[0][1]);
  113. ZZ            ac--; av++;
  114. ZZ        }
  115. ZZ        else break;
  116. ZZ    }
  117. ZZ
  118. ZZ    /* ------------------------------------------------------------ */
  119. ZZ    /* If any files, then process each                              */
  120. ZZ    /* ------------------------------------------------------------ */
  121. ZZ
  122. ZZ    if (ac)
  123. ZZ    {
  124. ZZ    /* ------------------------------------------------------------ */
  125. ZZ    /* If more than one file name specified, display headers        */
  126. ZZ    /* ------------------------------------------------------------ */
  127. ZZ
  128. ZZ        header = ac > 1;
  129. ZZ        while (ac--)
  130. ZZ        {
  131. ZZ            if (!strcmp (*av, "-"))
  132. ZZ            {
  133. ZZ                dofile (stdin, "standard input", skip, nlines, header);
  134. ZZ            }
  135. ZZ            else if (!(in = fopen (*av, "r")))
  136. ZZ            {
  137. ZZ                fprintf (stderr,
  138. ZZ                    "head: cannot read file %s - skipping\n", *av);
  139. ZZ            }
  140. ZZ            else
  141. ZZ            {
  142. ZZ                dofile (in, *av, skip, nlines, header);
  143. ZZ                fclose (in);
  144. ZZ            }
  145. ZZ            av++;
  146. ZZ        }
  147. ZZ    }
  148. ZZ    else dofile (stdin, "standard input", skip, nlines, FALSE);
  149. ZZ
  150. ZZ    exit (0);
  151. ZZ}
  152. ZZ/* ------------------------------------------------------------ */
  153. ZZ/* Process a file, skipping and displaying as necessary         */
  154. ZZ/* ------------------------------------------------------------ */
  155. ZZvoid
  156. ZZdofile (in, inname, skip, nlines, dohead)
  157. ZZregister FILE *in;          /* input stream                         */
  158. ZZregister char *inname;      /* input file name                      */
  159. ZZregister long skip;         /* number of lines to skip              */
  160. ZZregister long nlines;       /* number of lines to display           */
  161. ZZ         int dohead;        /* TRUE if header is to be displayed    */
  162. ZZ{
  163. ZZ    register char *c;           /* convenient local pointer         */
  164. ZZ    register long lineno = 0;   /* line number in file              */
  165. ZZ
  166. ZZ    char    inbuf[1024];        /* line buffer                      */
  167. ZZ
  168. ZZ    /* ------------------------------------------------------------ */
  169. ZZ    /* Print header if necessary                                    */
  170. ZZ    /* ------------------------------------------------------------ */
  171. ZZ
  172. ZZ    if (dohead)
  173. ZZ    {
  174. ZZ        printf ("\
  175. ZZ+-----------------------------------------------------------------+\n\
  176. ZZ+                %-40.40s         +\n\
  177. ZZ+-----------------------------------------------------------------+\n",
  178. ZZ            inname);
  179. ZZ    }
  180. ZZ
  181. ZZ    /* ------------------------------------------------------------ */
  182. ZZ    /* Skip lines                                                   */
  183. ZZ    /* ------------------------------------------------------------ */
  184. ZZ
  185. ZZ    while (lineno++ < skip && fgets (inbuf, sizeof inbuf, in));
  186. ZZ
  187. ZZ    /* ------------------------------------------------------------ */
  188. ZZ    /* Display lines                                                */
  189. ZZ    /* ------------------------------------------------------------ */
  190. ZZ
  191. ZZ    lineno = 0;
  192. ZZ
  193. ZZ    while (lineno++ < nlines && fgets (inbuf, sizeof inbuf, in))
  194. ZZ        fputs (inbuf, stdout);
  195. ZZ    
  196. ZZ    return;
  197. ZZ}
  198. SHAR_EOF
  199. if test 4938 -ne "`wc -c < 'head.c'`"
  200. then
  201.     echo shar: error transmitting "'head.c'" '(should have been 4938 characters)'
  202. fi
  203. fi # end of overwriting check
  204. echo shar: extracting "'ctags.c'" '(6771 characters)'
  205. if test -f 'ctags.c'
  206. then
  207.     echo shar: will not over-write existing file "'ctags.c'"
  208. else
  209. sed 's/^ZZ//' << \SHAR_EOF > 'ctags.c'
  210. ZZ/*T ctags - generate VI tags file from C sources */
  211. ZZ/*S globals and stuff */
  212. ZZ#include    <stdio.h>
  213. ZZ#include    <ctype.h>
  214. ZZ
  215. ZZ#define EQ ==
  216. ZZ#define NE !=
  217. ZZ#define GT >
  218. ZZ#define GE >=
  219. ZZ#define LT <
  220. ZZ#define LE <=
  221. ZZ#define OR ||
  222. ZZ#define AND &&
  223. ZZ
  224. ZZ#define TRUE 1
  225. ZZ#define FALSE 0
  226. ZZ
  227. ZZ#define SPACE ' '
  228. ZZ#define NUL '\0'
  229. ZZ
  230. ZZtypedef short   BOOL;
  231. ZZ
  232. ZZchar    FunctionName[40];
  233. ZZ
  234. ZZchar    *ReservedWord[]  = { 
  235. ZZ     "BOOL", "auto", "bool", "break", "case", "char", "continue",
  236. ZZ     "default", "do", "double", "else", "entry", "enum",
  237. ZZ     "extern", "float", "for", "goto", "if",
  238. ZZ     "int", "long", "register", "return", "short",
  239. ZZ     "sizeof", "static", "struct", "switch",
  240. ZZ     "typedef", "union", "unsigned", "void", "while",
  241. ZZ     NULL };
  242. ZZ
  243. ZZchar    *pgm;
  244. ZZchar    inbuf[512];
  245. ZZ
  246. ZZextern char *strchr ();            /* index on BSD                        */
  247. ZZextern char *strrchr ();        /* rindex on BSD                    */
  248. ZZextern char *strpbrk ();        /* ???                                */
  249. ZZ
  250. ZZint     skiptoend ();            /* skip to end of function            */
  251. ZZchar    ckfunc ();                /* check for function declaration    */
  252. ZZ/*Page Eject*/
  253. ZZmain (ac, av)
  254. ZZint        ac;
  255. ZZchar    *av[];
  256. ZZ{
  257. ZZ    register FILE *in;            /* input file stream                */
  258. ZZ    register FILE *tagfile;        /* `tags' file being created        */
  259. ZZ
  260. ZZ    register char *cp;            /* convenient character pointers    */
  261. ZZ    register char *ep;            /*                                    */
  262. ZZ
  263. ZZ    register int i;                    /* loop index and such            */
  264. ZZ    register int index = FALSE;        /* if true, produce a functions    */
  265. ZZ                                    /* index instead of tags file    */
  266. ZZ    register int line_number = 0;    /* line number of declaration    */
  267. ZZ    register int optind = 1;        /* like getopt - command arg    */
  268. ZZ
  269. ZZ    char    *funcname;                /* function name                */
  270. ZZ
  271. ZZ    char    filename[15];            /* like it says                    */
  272. ZZ
  273. ZZ    if (pgm = strrchr (av[0], '/')) pgm++;
  274. ZZ    else                             pgm = av[0];
  275. ZZ
  276. ZZ    /* ------------------------------------------------------------ */
  277. ZZ    /* Create the tags file                                         */
  278. ZZ    /* ------------------------------------------------------------ */
  279. ZZ
  280. ZZ    tagfile = fopen ("tags", "w");
  281. ZZ    if (!tagfile)
  282. ZZ    {
  283. ZZ        perror ("tags");
  284. ZZ        fprintf (stderr,
  285. ZZ            "%s: cannot create file tags\n", pgm);
  286. ZZ        exit (1);
  287. ZZ    }
  288. ZZ
  289. ZZ    /* ------------------------------------------------------------ */
  290. ZZ    /* If selected, write a function index to stdout instead        */
  291. ZZ    /* ------------------------------------------------------------ */
  292. ZZ
  293. ZZ    if (!strncmp (av[1], "-x", 2))
  294. ZZ    {
  295. ZZ        index = TRUE;
  296. ZZ        optind++;
  297. ZZ    }
  298. ZZ
  299. ZZ    /* ------------------------------------------------------------ */
  300. ZZ    /* Process each file specified on the command line              */
  301. ZZ    /* ------------------------------------------------------------ */
  302. ZZ
  303. ZZ    for (i = optind; i LT ac; i++)
  304. ZZ    {
  305. ZZ        if (!(in = fopen (av[i], "r")))
  306. ZZ        {
  307. ZZ            perror (av[i]);
  308. ZZ            fprintf (stderr,
  309. ZZ                "%s: unable to read file %s\n", pgm, av[i]);
  310. ZZ        }
  311. ZZ        else
  312. ZZ        {
  313. ZZ            while (fgets (inbuf, sizeof inbuf, in))
  314. ZZ            {
  315. ZZ                line_number++;
  316. ZZ                if (ckfunc (inbuf))
  317. ZZ                {
  318. ZZ    /* ------------------------------------------------------------ */
  319. ZZ    /* Found a function declaration                                 */
  320. ZZ    /* ------------------------------------------------------------ */
  321. ZZ
  322. ZZ                    inbuf[strlen(inbuf)-1] = NUL;
  323. ZZ                    if (index)
  324. ZZ                    {
  325. ZZ                        printf ("%-20.20s  %6d  %s\t%s\n",
  326. ZZ                            FunctionName, line_number, av[i], inbuf);
  327. ZZ                    }
  328. ZZ    /* ------------------------------------------------------------ */
  329. ZZ    /* Special case function name `main'                            */
  330. ZZ    /* ------------------------------------------------------------ */
  331. ZZ                    else if (!strcmp (FunctionName, "main"))
  332. ZZ                    {
  333. ZZ                        cp = strrchr (av[i], '/');
  334. ZZ                        if (cp) cp++;
  335. ZZ                        else cp = av[i];
  336. ZZ                        strcpy (filename, cp);
  337. ZZ                        ep = strrchr (filename, '.');
  338. ZZ                        if (ep) *ep = NUL;
  339. ZZ                        fprintf (tagfile, "M%s\t%s\t?^%s$?\n",
  340. ZZ                            filename, av[i], inbuf);
  341. ZZ                    }
  342. ZZ                    else
  343. ZZ                    {
  344. ZZ                        fprintf (tagfile, "%s\t%s\t?^%s$?\n",
  345. ZZ                            FunctionName, av[i], inbuf);
  346. ZZ                    }
  347. ZZ                    line_number += skiptoend (in);
  348. ZZ                }
  349. ZZ            }
  350. ZZ            fclose (in);
  351. ZZ        }
  352. ZZ    }
  353. ZZ    fclose (tagfile);
  354. ZZ
  355. ZZ    /* ------------------------------------------------------------ */
  356. ZZ    /* Tags file must be sorted alphabetically on tag               */
  357. ZZ    /* ------------------------------------------------------------ */
  358. ZZ
  359. ZZ    system ("sort -u -t'\t' +0 -1 -o tags tags");
  360. ZZ
  361. ZZ    exit (0);
  362. ZZ}
  363. ZZ/*S ckfunc - check line for function declaration */
  364. ZZ/*H ckfunc */
  365. ZZ/*E*/
  366. ZZ
  367. ZZ#define isidchr(c) (isalnum(c) OR (c EQ '_'))
  368. ZZ
  369. ZZchar
  370. ZZckfunc (s)
  371. ZZregister char   *s;                /* string to check for declaration    */
  372. ZZ{
  373. ZZ    register char *p;            /* convenient character pointer        */
  374. ZZ    register int  i;            /* useful loop index                 */
  375. ZZ    register int  result;        /* used to terminate search loop    */
  376. ZZ    register char found = FALSE;    /* true if declaration found    */
  377. ZZ
  378. ZZ    static char *_fnm = "ckfunc";
  379. ZZ
  380. ZZ    /* ------------------------------------------------------------ */
  381. ZZ    /* There's GOT to be a left paren for there to be a declaration */
  382. ZZ    /* ------------------------------------------------------------ */
  383. ZZ
  384. ZZ    if (strchr (s, '('))
  385. ZZ    {
  386. ZZ        found = TRUE;
  387. ZZ
  388. ZZ        while (found)
  389. ZZ        {
  390. ZZ            found = FALSE;
  391. ZZ            p = FunctionName;
  392. ZZ            for (s; isascii (*s) AND isspace (*s) AND *s; s++);
  393. ZZ            if( *s EQ '*' )
  394. ZZ            {
  395. ZZ                for (++s; isascii (*s) AND isspace (*s) AND *s; s++);
  396. ZZ            }
  397. ZZ
  398. ZZ            if ((*s EQ '_') OR isalpha(*s))
  399. ZZ            {
  400. ZZ                while (isidchr (*s)) *p++ = *s++;
  401. ZZ
  402. ZZ                *p = NUL;
  403. ZZ
  404. ZZ                for (found = FALSE, i = 0;
  405. ZZ                     !found AND ReservedWord[i]; i++)
  406. ZZ                {
  407. ZZ                    if (!(result = strcmp (FunctionName, ReservedWord[i])))
  408. ZZ                        found = TRUE;
  409. ZZ                    else if  (result LT 0) break;
  410. ZZ                }
  411. ZZ            }
  412. ZZ        }
  413. ZZ    }
  414. ZZ    
  415. ZZ    for (s; isascii (*s) AND isspace (*s) AND *s; s++);
  416. ZZ
  417. ZZ    if (*s EQ '(')
  418. ZZ    {
  419. ZZ        for (found = FALSE; *s AND !found; s++)
  420. ZZ            found = *s EQ ')';
  421. ZZ        
  422. ZZ        if (found)
  423. ZZ        {
  424. ZZ            for (; *s AND isspace (*s); s++);
  425. ZZ
  426. ZZ            found = *s NE ';';
  427. ZZ        }
  428. ZZ    }
  429. ZZ
  430. ZZ    return found;
  431. ZZ}
  432. ZZ/* ------------------------------------------------------------ */
  433. ZZ/* Skiptoend is called after a function declaration is found    */
  434. ZZ/* to skip to the end of the function.                          */
  435. ZZ/* ------------------------------------------------------------ */
  436. ZZint
  437. ZZskiptoend (in)
  438. ZZregister FILE *in;            /* file being processed                    */
  439. ZZ{
  440. ZZ    register int nest = 0;        /* nesting level - zero means end    */
  441. ZZ    register int c;                /* character being checked            */
  442. ZZ    register int line_number = 0;    /* like it says                    */
  443. ZZ
  444. ZZ    /* ------------------------------------------------------------ */
  445. ZZ    /* Simpleminded search for the starting brace                   */
  446. ZZ    /* ------------------------------------------------------------ */
  447. ZZ
  448. ZZ    while (((c = getc (in)) NE EOF) AND c NE '{')
  449. ZZ        if (c EQ '\n') line_number++;
  450. ZZ
  451. ZZ    nest++;
  452. ZZ
  453. ZZ    /* ------------------------------------------------------------ */
  454. ZZ    /* Keep going until the paired brace is found                   */
  455. ZZ    /* ------------------------------------------------------------ */
  456. ZZ
  457. ZZ    while (nest AND ((c = getc (in)) NE EOF))
  458. ZZ    {
  459. ZZ        switch (c)
  460. ZZ        {
  461. ZZ            case    '{':    nest++; break;
  462. ZZ            case    '}':    nest--; break;
  463. ZZ            case    '\n':    line_number++;
  464. ZZ        }
  465. ZZ    }
  466. ZZ
  467. ZZ    return line_number;
  468. ZZ}
  469. SHAR_EOF
  470. if test 6771 -ne "`wc -c < 'ctags.c'`"
  471. then
  472.     echo shar: error transmitting "'ctags.c'" '(should have been 6771 characters)'
  473. fi
  474. fi # end of overwriting check
  475. #    End of shell archive
  476. exit 0
  477.  
  478.  
  479.  
  480.